@automattic/vip 4.1.4 → 4.1.6

package/internal/keychain/keychain.go

@@ -1,197 +0,0 @@
-// Package keychain wraps the OS credential store.
-//
-// On macOS, Windows, and Linux+libsecret it uses zalando/go-keyring.
-// The file fallback (Task 9) covers headless Linux where Secret Service
-// is not available.
-//
-// vip-next owns a separate credential namespace so its keyring representation
-// cannot overwrite credentials used by the Node CLI. The legacy Node service
-// name is retained for read-only, best-effort token fallback:
-//
-//   - vip-next production → "vip-next-cli"
-//   - Node production     → "vip-go-cli"
-//   - Non-production      → "<base>:<sanitized-url>"
-//
-// where <sanitized-url> is the full API host URL with every non-alphanumeric
-// character replaced by "-", matching:
-//
-//	API_HOST.replace(/[^a-z0-9]/gi, '-')   (src/lib/token.ts getServiceName)
-//
-// Callers pass k.Account() — which equals k.Service — as the user argument to
-// primary Set/Get/Delete operations. Legacy entries are never written or
-// deleted by this package's authentication store.
-package keychain
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-	"sync"
-
-	keyring "github.com/zalando/go-keyring"
-)
-
-// ProductionAPIHost is the canonical production endpoint. Both the private
-// and legacy namespaces omit a host suffix for this endpoint.
-const ProductionAPIHost = "https://api.wpvip.com"
-
-const (
-	// service is the Go CLI's private credential namespace.
-	service = "vip-next-cli"
-	// legacyService is the Node CLI namespace used only for best-effort reads.
-	legacyService = "vip-go-cli"
-)
-
-// ErrNotFound is returned by Get/Delete when the secret does not exist.
-var ErrNotFound = errors.New("keychain: secret not found")
-
-// nonAlphanumeric matches characters that Node replaces with "-".
-var nonAlphanumeric = regexp.MustCompile(`[^a-zA-Z0-9]`)
-
-// Backend abstracts the credential store so tests can inject an in-memory
-// double and the file fallback can satisfy the same interface.
-type Backend interface {
-	Set(service, user, secret string) error
-	Get(service, user string) (string, error)
-	Delete(service, user string) error
-}
-
-// Keychain is a scoped handle to a particular credential namespace.
-type Keychain struct {
-	Backend       Backend
-	Service       string
-	LegacyService string
-}
-
-// New returns a Keychain with private and legacy service names derived from the
-// same API host.
-//
-// It uses the OS keyring where one is available, and falls back to a 0600 file
-// store on a headless Linux box where the Secret Service (D-Bus) is not
-// reachable so vip-next still works over SSH, in WSL, and in CI.
-func New(host string) *Keychain {
-	backend := chooseBackend(runtime.GOOS, secretServiceReachable, fallbackDir())
-	if fb, ok := backend.(*FileBackend); ok {
-		warnFileFallbackOnce(fb.path())
-	}
-	return &Keychain{
-		Backend:       backend,
-		Service:       ServiceNameForHost(host),
-		LegacyService: LegacyServiceNameForHost(host),
-	}
-}
-
-// Account returns the private service name used as the default account for
-// password operations.
-func (k *Keychain) Account() string { return k.Service }
-
-// Set stores secret under the given user account.
-func (k *Keychain) Set(user, secret string) error {
-	return k.Backend.Set(k.Service, user, secret)
-}
-
-// Get retrieves the secret stored under user. Returns ErrNotFound when absent.
-func (k *Keychain) Get(user string) (string, error) {
-	return k.Backend.Get(k.Service, user)
-}
-
-// Delete removes the secret stored under user. Returns ErrNotFound when absent.
-func (k *Keychain) Delete(user string) error {
-	return k.Backend.Delete(k.Service, user)
-}
-
-func serviceNameForHost(base, host string) string {
-	// Normalise trailing slash so comparison is robust.
-	normalized := strings.TrimRight(host, "/")
-	if normalized == ProductionAPIHost {
-		return base
-	}
-	sanitized := nonAlphanumeric.ReplaceAllString(normalized, "-")
-	return base + ":" + sanitized
-}
-
-// ServiceNameForHost derives vip-next's private service name from an API host.
-func ServiceNameForHost(host string) string {
-	return serviceNameForHost(service, host)
-}
-
-// LegacyServiceNameForHost derives the Node CLI service name used only for
-// best-effort token reads.
-func LegacyServiceNameForHost(host string) string {
-	return serviceNameForHost(legacyService, host)
-}
-
-// defaultBackend delegates to zalando/go-keyring (OS credential store).
-type defaultBackend struct{}
-
-func (defaultBackend) Set(svc, user, secret string) error {
-	return keyring.Set(svc, user, secret)
-}
-
-func (defaultBackend) Get(svc, user string) (string, error) {
-	v, err := keyring.Get(svc, user)
-	if errors.Is(err, keyring.ErrNotFound) {
-		return "", ErrNotFound
-	}
-	return v, err
-}
-
-func (defaultBackend) Delete(svc, user string) error {
-	err := keyring.Delete(svc, user)
-	if errors.Is(err, keyring.ErrNotFound) {
-		return ErrNotFound
-	}
-	return err
-}
-
-// secretServiceProbeUser is a sentinel account used only to probe whether the
-// Linux Secret Service is reachable; it is never stored.
-const secretServiceProbeUser = "__vip_secret_service_probe__"
-
-// chooseBackend picks the OS keyring, or the file fallback on a headless Linux
-// box where the Secret Service is unavailable. macOS and Windows always have a
-// credential store, so their probe is skipped. Kept pure (probe + dir injected)
-// so the selection is unit-testable.
-func chooseBackend(goos string, keyringReachable func() bool, fileDir string) Backend {
-	if goos != "linux" || keyringReachable() {
-		return defaultBackend{}
-	}
-	return &FileBackend{Dir: fileDir}
-}
-
-// secretServiceReachable probes the Linux Secret Service with a cheap Get:
-// keyring.ErrNotFound means it is reachable (the probe account is simply
-// absent); any other error (e.g. no D-Bus session bus on a headless host)
-// means it is unavailable.
-func secretServiceReachable() bool {
-	_, err := keyring.Get(service, secretServiceProbeUser)
-	return err == nil || errors.Is(err, keyring.ErrNotFound)
-}
-
-// fallbackDir is where the file backend writes credentials.json when the OS
-// keyring is unavailable — the user config dir (…/vip), alongside where the
-// Node CLI's configstore fallback lives.
-func fallbackDir() string {
-	if d, err := os.UserConfigDir(); err == nil && d != "" {
-		return filepath.Join(d, "vip")
-	}
-	if h, err := os.UserHomeDir(); err == nil && h != "" {
-		return filepath.Join(h, ".vip")
-	}
-	return "vip"
-}
-
-// fileFallbackWarnOnce guards the single stderr notice below.
-var fileFallbackWarnOnce sync.Once
-
-// warnFileFallbackOnce prints one stderr notice that credentials are stored in a
-// file rather than the OS keyring (the FileBackend's expected caller warning).
-func warnFileFallbackOnce(path string) {
-	fileFallbackWarnOnce.Do(func() {
-		fmt.Fprintf(os.Stderr, "warning: OS keyring unavailable; storing credentials in %s (0600)\n", path)
-	})
-}

package/internal/keychain/keychain_select_test.go

@@ -1,34 +0,0 @@
-package keychain
-
-import "testing"
-
-func TestChooseBackend(t *testing.T) {
-	up := func() bool { return true }
-	down := func() bool { return false }
-
-	// Headless Linux (Secret Service unreachable) -> file fallback.
-	if _, ok := chooseBackend("linux", down, "/tmp/vip").(*FileBackend); !ok {
-		t.Fatalf("linux without a reachable keyring must use the file fallback")
-	}
-	// Linux with a working Secret Service -> OS keyring.
-	if _, ok := chooseBackend("linux", up, "/tmp/vip").(defaultBackend); !ok {
-		t.Fatalf("linux with a reachable keyring must use the OS keyring")
-	}
-	// macOS / Windows always have a credential store; the probe must be skipped.
-	for _, goos := range []string{"darwin", "windows"} {
-		probed := false
-		probe := func() bool { probed = true; return false }
-		if _, ok := chooseBackend(goos, probe, "/tmp/vip").(defaultBackend); !ok {
-			t.Fatalf("%s must use the OS keyring", goos)
-		}
-		if probed {
-			t.Fatalf("%s must not probe the Secret Service", goos)
-		}
-	}
-}
-
-func TestFallbackDir(t *testing.T) {
-	if d := fallbackDir(); d == "" {
-		t.Fatal("fallbackDir must return a non-empty path")
-	}
-}

package/internal/keychain/keychain_test.go

@@ -1,112 +0,0 @@
-package keychain
-
-import (
-	"errors"
-	"os"
-	"testing"
-)
-
-type memBackend struct {
-	store map[string]string
-}
-
-func (m *memBackend) Set(service, user, secret string) error {
-	if m.store == nil {
-		m.store = map[string]string{}
-	}
-	m.store[service+"|"+user] = secret
-	return nil
-}
-func (m *memBackend) Get(service, user string) (string, error) {
-	v, ok := m.store[service+"|"+user]
-	if !ok {
-		return "", ErrNotFound
-	}
-	return v, nil
-}
-func (m *memBackend) Delete(service, user string) error {
-	delete(m.store, service+"|"+user)
-	return nil
-}
-
-func TestRoundTrip(t *testing.T) {
-	k := &Keychain{Backend: &memBackend{}, Service: "vip-go-cli-test"}
-
-	if err := k.Set("rinat", "secret-value"); err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	got, err := k.Get("rinat")
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	if got != "secret-value" {
-		t.Errorf("Get = %q, want %q", got, "secret-value")
-	}
-}
-
-func TestGetMissingReturnsNotFound(t *testing.T) {
-	k := &Keychain{Backend: &memBackend{}, Service: "vip-go-cli-test"}
-	_, err := k.Get("absent")
-	if !errors.Is(err, ErrNotFound) {
-		t.Errorf("err = %v, want ErrNotFound", err)
-	}
-}
-
-func TestServiceNamesAreHostSpecific(t *testing.T) {
-	if got := ServiceNameForHost("https://api.wpvip.com"); got != "vip-next-cli" {
-		t.Errorf("ServiceNameForHost prod = %q, want %q", got, "vip-next-cli")
-	}
-	if got := ServiceNameForHost("https://staging-api.wpvip.com:8443"); got != "vip-next-cli:https---staging-api-wpvip-com-8443" {
-		t.Errorf("ServiceNameForHost staging = %q, want %q", got, "vip-next-cli:https---staging-api-wpvip-com-8443")
-	}
-	if got := LegacyServiceNameForHost("https://api.wpvip.com"); got != "vip-go-cli" {
-		t.Errorf("LegacyServiceNameForHost prod = %q, want %q", got, "vip-go-cli")
-	}
-	if got := LegacyServiceNameForHost("https://staging-api.wpvip.com:8443"); got != "vip-go-cli:https---staging-api-wpvip-com-8443" {
-		t.Errorf("LegacyServiceNameForHost staging = %q, want %q", got, "vip-go-cli:https---staging-api-wpvip-com-8443")
-	}
-}
-
-func TestFileBackendRoundTrip(t *testing.T) {
-	dir := t.TempDir()
-	b := &FileBackend{Dir: dir}
-
-	if err := b.Set("svc", "user", "secret"); err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	got, err := b.Get("svc", "user")
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	if got != "secret" {
-		t.Errorf("Get = %q, want %q", got, "secret")
-	}
-	if err := b.Delete("svc", "user"); err != nil {
-		t.Fatalf("Delete: %v", err)
-	}
-	if _, err := b.Get("svc", "user"); !errors.Is(err, ErrNotFound) {
-		t.Errorf("expected ErrNotFound after delete, got %v", err)
-	}
-}
-
-func TestAccountEqualsService(t *testing.T) {
-	k := &Keychain{Service: "vip-next-cli"}
-	if k.Account() != "vip-next-cli" {
-		t.Errorf("Account() = %q, want %q", k.Account(), "vip-next-cli")
-	}
-}
-
-func TestFileBackendCreatesFileMode0600(t *testing.T) {
-	dir := t.TempDir()
-	b := &FileBackend{Dir: dir}
-	if err := b.Set("svc", "user", "secret"); err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	info, err := os.Stat(b.path())
-	if err != nil {
-		t.Fatalf("Stat: %v", err)
-	}
-	if info.Mode().Perm() != 0o600 {
-		t.Errorf("file mode = %o, want 0600", info.Mode().Perm())
-	}
-}

package/internal/logsapi/logsapi.go

@@ -1,165 +0,0 @@
-// Package logsapi wraps the GetAppLogs genqlient operation behind a flat
-// Go-friendly surface. The schema field is `AppEnvironment.logs(type,
-// limit, after)` and returns `AppEnvironmentLogsList` (`nodes`,
-// `nextCursor`, `pollingDelaySeconds`).
-//
-// The Node parity source is src/lib/app-logs/app-logs.ts (getRecentLogs).
-//
-// We walk the genqlient response via reflection — mirroring the envvar
-// package — so callers don't need to know the deeply-nested generated
-// type names (e.g. GetAppLogsAppEnvironmentsAppEnvironmentLogsAppEnvironmentLogsList).
-package logsapi
-
-import (
-	"context"
-	"reflect"
-
-	"github.com/Khan/genqlient/graphql"
-
-	"github.com/Automattic/vip/internal/gql"
-)
-
-// LIMIT_MAX is the server-side ceiling for the `limit` argument on the
-// logs query. Mirrors Node's app-logs.ts export. Callers (the polling
-// loop in particular) use this as the cap on subsequent fetches.
-const LIMIT_MAX = 5000
-
-// LogNode is one log line: a timestamp + message.
-type LogNode struct {
-	Timestamp string
-	Message   string
-}
-
-// Page is a single response page from the logs endpoint.
-type Page struct {
-	Nodes               []LogNode
-	NextCursor          *string
-	PollingDelaySeconds int
-}
-
-// RecentLogs runs GetAppLogs and flattens the response into a Page. The
-// logType must be one of `app` or `batch` — validation lives at the
-// command-line layer to match Node's exact error wording.
-func RecentLogs(ctx context.Context, c graphql.Client, appID, envID int64, logType string, limit int, after *string) (*Page, error) {
-	resp, err := gql.GetAppLogs(ctx, c, appID, envID, gql.AppEnvironmentLogType(logType), int64(limit), after)
-	if err != nil {
-		return nil, err
-	}
-	return reflectLogsResponse(resp), nil
-}
-
-// reflectLogsResponse walks app → environments[0] → logs → {nodes,
-// nextCursor, pollingDelaySeconds}. Uses reflection to avoid coupling
-// to genqlient's verbose generated type names (which change whenever
-// the operation shape changes). Returns an empty Page (non-nil) on any
-// missing field — the command layer treats len(Nodes)==0 as the
-// "no logs found" case.
-func reflectLogsResponse(v any) *Page {
-	p := &Page{Nodes: []LogNode{}}
-	rv := reflect.ValueOf(v)
-	for rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			return p
-		}
-		rv = rv.Elem()
-	}
-	if rv.Kind() != reflect.Struct {
-		return p
-	}
-	app := rv.FieldByName("App")
-	for app.Kind() == reflect.Ptr {
-		if app.IsNil() {
-			return p
-		}
-		app = app.Elem()
-	}
-	if !app.IsValid() || app.Kind() != reflect.Struct {
-		return p
-	}
-	envs := app.FieldByName("Environments")
-	if !envs.IsValid() || envs.Kind() != reflect.Slice || envs.Len() == 0 {
-		return p
-	}
-	env := envs.Index(0)
-	for env.Kind() == reflect.Ptr {
-		if env.IsNil() {
-			return p
-		}
-		env = env.Elem()
-	}
-	if env.Kind() != reflect.Struct {
-		return p
-	}
-	logs := env.FieldByName("Logs")
-	for logs.Kind() == reflect.Ptr {
-		if logs.IsNil() {
-			return p
-		}
-		logs = logs.Elem()
-	}
-	if !logs.IsValid() || logs.Kind() != reflect.Struct {
-		return p
-	}
-	if nc := logs.FieldByName("NextCursor"); nc.IsValid() {
-		switch nc.Kind() {
-		case reflect.Ptr:
-			if !nc.IsNil() {
-				s := nc.Elem().String()
-				p.NextCursor = &s
-			}
-		case reflect.String:
-			s := nc.String()
-			p.NextCursor = &s
-		}
-	}
-	if pd := logs.FieldByName("PollingDelaySeconds"); pd.IsValid() {
-		switch pd.Kind() {
-		case reflect.Ptr:
-			if !pd.IsNil() {
-				p.PollingDelaySeconds = int(pd.Elem().Int())
-			}
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			p.PollingDelaySeconds = int(pd.Int())
-		}
-	}
-	nodes := logs.FieldByName("Nodes")
-	if !nodes.IsValid() || nodes.Kind() != reflect.Slice {
-		return p
-	}
-	for i := 0; i < nodes.Len(); i++ {
-		n := nodes.Index(i)
-		for n.Kind() == reflect.Ptr {
-			if n.IsNil() {
-				n = reflect.Value{}
-				break
-			}
-			n = n.Elem()
-		}
-		if !n.IsValid() || n.Kind() != reflect.Struct {
-			continue
-		}
-		var item LogNode
-		if f := n.FieldByName("Timestamp"); f.IsValid() {
-			switch f.Kind() {
-			case reflect.Ptr:
-				if !f.IsNil() {
-					item.Timestamp = f.Elem().String()
-				}
-			case reflect.String:
-				item.Timestamp = f.String()
-			}
-		}
-		if f := n.FieldByName("Message"); f.IsValid() {
-			switch f.Kind() {
-			case reflect.Ptr:
-				if !f.IsNil() {
-					item.Message = f.Elem().String()
-				}
-			case reflect.String:
-				item.Message = f.String()
-			}
-		}
-		p.Nodes = append(p.Nodes, item)
-	}
-	return p
-}

package/internal/logsapi/logsapi_test.go

@@ -1,82 +0,0 @@
-package logsapi
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/Khan/genqlient/graphql"
-)
-
-// logsServer returns a stub /graphql endpoint that responds with the given
-// JSON body for every request. Sufficient because each RecentLogs call
-// fires exactly one query.
-func logsServer(body string) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(body))
-	}))
-}
-
-func TestRecentLogsHappyPath(t *testing.T) {
-	srv := logsServer(`{"data":{"app":{"id":1,"environments":[{"id":2,"logs":{"nodes":[{"timestamp":"2024-01-01T00:00:00Z","message":"hello"},{"timestamp":"2024-01-01T00:00:01Z","message":"world"}],"nextCursor":"abc","pollingDelaySeconds":7}}]}}}`)
-	defer srv.Close()
-	c := graphql.NewClient(srv.URL+"/graphql", srv.Client())
-
-	page, err := RecentLogs(context.Background(), c, 1, 2, "app", 500, nil)
-	if err != nil {
-		t.Fatalf("RecentLogs: %v", err)
-	}
-	if len(page.Nodes) != 2 {
-		t.Fatalf("Nodes len = %d, want 2 (page=%+v)", len(page.Nodes), page)
-	}
-	if page.Nodes[0].Timestamp != "2024-01-01T00:00:00Z" || page.Nodes[0].Message != "hello" {
-		t.Errorf("Nodes[0] = %+v, want {2024-01-01T00:00:00Z hello}", page.Nodes[0])
-	}
-	if page.Nodes[1].Timestamp != "2024-01-01T00:00:01Z" || page.Nodes[1].Message != "world" {
-		t.Errorf("Nodes[1] = %+v, want {2024-01-01T00:00:01Z world}", page.Nodes[1])
-	}
-	if page.NextCursor == nil || *page.NextCursor != "abc" {
-		t.Errorf("NextCursor = %v, want abc", page.NextCursor)
-	}
-	if page.PollingDelaySeconds != 7 {
-		t.Errorf("PollingDelaySeconds = %d, want 7", page.PollingDelaySeconds)
-	}
-}
-
-func TestRecentLogsEmpty(t *testing.T) {
-	srv := logsServer(`{"data":{"app":{"id":1,"environments":[{"id":2,"logs":{"nodes":[],"nextCursor":null,"pollingDelaySeconds":15}}]}}}`)
-	defer srv.Close()
-	c := graphql.NewClient(srv.URL+"/graphql", srv.Client())
-
-	page, err := RecentLogs(context.Background(), c, 1, 2, "app", 500, nil)
-	if err != nil {
-		t.Fatalf("RecentLogs: %v", err)
-	}
-	if len(page.Nodes) != 0 {
-		t.Errorf("Nodes len = %d, want 0; page=%+v", len(page.Nodes), page)
-	}
-	if page.NextCursor != nil {
-		t.Errorf("NextCursor = %v, want nil", page.NextCursor)
-	}
-	if page.PollingDelaySeconds != 15 {
-		t.Errorf("PollingDelaySeconds = %d, want 15", page.PollingDelaySeconds)
-	}
-}
-
-func TestRecentLogsBatchType(t *testing.T) {
-	// Same payload as happy path, but with the batch type — exercising the
-	// enum-cast path through gql.AppEnvironmentLogType.
-	srv := logsServer(`{"data":{"app":{"id":1,"environments":[{"id":2,"logs":{"nodes":[{"timestamp":"t","message":"m"}],"pollingDelaySeconds":30}}]}}}`)
-	defer srv.Close()
-	c := graphql.NewClient(srv.URL+"/graphql", srv.Client())
-
-	page, err := RecentLogs(context.Background(), c, 1, 2, "batch", 100, nil)
-	if err != nil {
-		t.Fatalf("RecentLogs(batch): %v", err)
-	}
-	if len(page.Nodes) != 1 || page.Nodes[0].Message != "m" {
-		t.Errorf("Nodes = %+v, want one {t m}", page.Nodes)
-	}
-}

package/internal/mediaimport/mediaimport.go

@@ -1,26 +0,0 @@
-// Package mediaimport ports src/lib/media-import/** — the media-import
-// status poller, its progress tracker, and the small helpers the three
-// `vip import media*` commands share.
-package mediaimport
-
-import (
-	"os"
-	"strings"
-)
-
-// IsLocalArchive ports isLocalArchive (media-import/utils.ts:3):
-// .tar.gz/.tgz/.zip (case-insensitive) AND an existing regular file.
-func IsLocalArchive(filePath string) bool {
-	lower := strings.ToLower(filePath)
-	if !strings.HasSuffix(lower, ".tar.gz") && !strings.HasSuffix(lower, ".tgz") &&
-		!strings.HasSuffix(lower, ".zip") {
-		return false
-	}
-	fi, err := os.Stat(filePath)
-	return err == nil && fi.Mode().IsRegular()
-}
-
-// IsSupportedApp ports isSupportedApp (media-file-import.ts:18):
-// app.type must be in SUPPORTED_MEDIA_FILE_IMPORT_SITE_TYPES, i.e.
-// exactly "WordPress".
-func IsSupportedApp(appType string) bool { return appType == "WordPress" }

package/internal/mediaimport/mediaimport_test.go

@@ -1,46 +0,0 @@
-package mediaimport
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestIsLocalArchive(t *testing.T) {
-	dir := t.TempDir()
-	mk := func(name string) string {
-		p := filepath.Join(dir, name)
-		if err := os.WriteFile(p, []byte("x"), 0o600); err != nil {
-			t.Fatal(err)
-		}
-		return p
-	}
-	targz := mk("a.tar.gz")
-	tgz := mk("b.TGZ") // case-insensitive (utils.ts:4 toLowerCase)
-	zip := mk("c.zip")
-	sql := mk("d.sql")
-
-	for p, want := range map[string]bool{
-		targz: true, tgz: true, zip: true, sql: false,
-		filepath.Join(dir, "missing.zip"): false, // stat fails -> false
-	} {
-		if got := IsLocalArchive(p); got != want {
-			t.Errorf("IsLocalArchive(%q) = %v, want %v", p, got, want)
-		}
-	}
-	// directory with archive extension -> false (stat.isFile, utils.ts:13)
-	archiveDir := filepath.Join(dir, "fake.zip")
-	if err := os.MkdirAll(archiveDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if IsLocalArchive(archiveDir) {
-		t.Error("directory must not count as a local archive")
-	}
-}
-
-func TestIsSupportedApp(t *testing.T) {
-	// SUPPORTED_MEDIA_FILE_IMPORT_SITE_TYPES = ['WordPress'] (media-file-import.ts:16)
-	if !IsSupportedApp("WordPress") || IsSupportedApp("node") || IsSupportedApp("") {
-		t.Error("IsSupportedApp must accept exactly 'WordPress'")
-	}
-}