feat(marketplace): live progress indicator during search scan

A rare keyword search scans much of the catalog and can take tens of seconds on
a slow link — long enough to look hung. Search now reports progress: the client
gained an optional OnProgress(scanned) callback (invoked after each batch), and
`marketplace search` wires it to a "Searching marketplace… N items scanned"
line on stderr.

Gated: shown only when stderr is an interactive terminal and output isn't
--json, so pipes, CI, and JSON consumers stay clean. The line is cleared before
results are printed.

Tests: OnProgress fires monotonically and totals the items scanned; the CLI
gate returns no-op for --json and non-terminal writers. PTY smoke-tested.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ako

cmd/mxcli/cmd_marketplace.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -14,6 +15,7 @@ import (
 	"github.com/mendixlabs/mxcli/internal/auth"
 	"github.com/mendixlabs/mxcli/internal/marketplace"
 	"github.com/spf13/cobra"
+	"golang.org/x/term"
 )
 
 var marketplaceCmd = &cobra.Command{
@@ -207,6 +209,15 @@ func runMarketplaceSearch(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+
+	// The Content API has no server-side search, so a rare query scans much of
+	// the catalog. Show progress on an interactive terminal so it doesn't look
+	// hung. Skipped for --json and non-terminal stderr (pipes, CI).
+	stderr := cmd.ErrOrStderr()
+	if progressDone := startSearchProgress(client, stderr, asJSON); progressDone != nil {
+		defer progressDone()
+	}
+
 	list, err := client.Search(cmd.Context(), query, limit)
 	if err != nil {
 		return err
@@ -217,6 +228,25 @@ func runMarketplaceSearch(cmd *cobra.Command, args []string) error {
 	return renderContentTable(cmd, list.Items)
 }
 
+// startSearchProgress wires a live "scanning" indicator on client.OnProgress
+// when stderr is an interactive terminal and output isn't JSON. It returns a
+// cleanup func that clears the progress line, or nil when no progress is shown.
+func startSearchProgress(client *marketplace.Client, stderr io.Writer, asJSON bool) func() {
+	if asJSON {
+		return nil
+	}
+	f, ok := stderr.(*os.File)
+	if !ok || !term.IsTerminal(int(f.Fd())) {
+		return nil
+	}
+	client.OnProgress = func(scanned int) {
+		fmt.Fprintf(stderr, "\rSearching marketplace… %d items scanned", scanned)
+	}
+	return func() {
+		fmt.Fprint(stderr, "\r\033[K") // clear the progress line
+	}
+}
+
 func runMarketplaceInfo(cmd *cobra.Command, args []string) error {
 	contentID, err := parseContentID(args[0])
 	if err != nil {

cmd/mxcli/cmd_marketplace_download_test.go

@@ -3,6 +3,7 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"net/http"
 	"os"
@@ -13,6 +14,28 @@ import (
 	"github.com/mendixlabs/mxcli/internal/marketplace"
 )
 
+func TestStartSearchProgress_Gating(t *testing.T) {
+	t.Run("nil for --json", func(t *testing.T) {
+		c := marketplace.New(http.DefaultClient)
+		if startSearchProgress(c, os.Stderr, true) != nil {
+			t.Error("expected no progress for --json output")
+		}
+		if c.OnProgress != nil {
+			t.Error("OnProgress must stay unset for --json")
+		}
+	})
+	t.Run("nil for non-terminal writer", func(t *testing.T) {
+		c := marketplace.New(http.DefaultClient)
+		// A bytes.Buffer is not an *os.File, so it's never an interactive terminal.
+		if startSearchProgress(c, &bytes.Buffer{}, false) != nil {
+			t.Error("expected no progress for a non-terminal writer (pipe/buffer)")
+		}
+		if c.OnProgress != nil {
+			t.Error("OnProgress must stay unset for a non-terminal writer")
+		}
+	})
+}
+
 func TestResolveVersion(t *testing.T) {
 	versions := []marketplace.Version{
 		{VersionNumber: "7.0.3", DownloadURL: "u3"},

internal/marketplace/client.go

@@ -38,6 +38,12 @@ const (
 type Client struct {
 	httpClient *http.Client
 	baseURL    string
+
+	// OnProgress, if set, is called after each batch of a keyword Search with
+	// the cumulative number of catalog items scanned so far. Used by the CLI to
+	// show progress during a long client-side scan. Called from Search's
+	// goroutine (not the fetch workers), so it needs no synchronisation.
+	OnProgress func(scanned int)
 }
 
 // New returns a marketplace client bound to the given HTTP client.
@@ -83,6 +89,7 @@ func (c *Client) Search(ctx context.Context, query string, limit int) (*ContentL
 	// (near-full scan) is a handful of round-trips instead of ~23 sequential
 	// ones. Stops at `limit` matches or end-of-catalog (a short page).
 	var matched []Content
+	scanned := 0
 	for page := 0; page < maxSearchPages; {
 		batch := searchConcurrency
 		if page == 0 {
@@ -100,10 +107,14 @@ func (c *Client) Search(ctx context.Context, query string, limit int) (*ContentL
 		endReached := false
 		for _, items := range pages {
 			matched = append(matched, filterItems(items, query)...)
+			scanned += len(items)
 			if len(items) < pageSize {
 				endReached = true
 			}
 		}
+		if c.OnProgress != nil {
+			c.OnProgress(scanned)
+		}
 		if limit > 0 && len(matched) >= limit {
 			matched = matched[:limit]
 			break

internal/marketplace/client_test.go

@@ -178,6 +178,41 @@ func TestSearch_PaginatesPastFirstPage(t *testing.T) {
 	}
 }
 
+// TestSearch_OnProgress: the progress callback fires after each batch with a
+// monotonic, cumulative count of items scanned, ending at the total scanned.
+func TestSearch_OnProgress(t *testing.T) {
+	client, _ := newMockServer(t, func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Query().Get("offset") {
+		case "0":
+			_, _ = w.Write([]byte(contentPage(1, 100, ""))) // full page
+		case "100":
+			_, _ = w.Write([]byte(contentPage(200, 100, ""))) // full page
+		case "200":
+			_, _ = w.Write([]byte(contentPage(400, 30, ""))) // short page -> end
+		default:
+			_, _ = w.Write([]byte(`{"items":[]}`))
+		}
+	})
+
+	var calls []int
+	client.OnProgress = func(scanned int) { calls = append(calls, scanned) }
+
+	if _, err := client.Search(context.Background(), "nomatch", 20); err != nil {
+		t.Fatal(err)
+	}
+	if len(calls) == 0 {
+		t.Fatal("OnProgress was never called")
+	}
+	for i := 1; i < len(calls); i++ {
+		if calls[i] < calls[i-1] {
+			t.Errorf("progress not monotonic: %v", calls)
+		}
+	}
+	if got := calls[len(calls)-1]; got != 230 { // 100 + 100 + 30
+		t.Errorf("final scanned = %d, want 230 (total items returned)", got)
+	}
+}
+
 // TestSearch_FirstPageAlone: when enough matches appear on the first (full)
 // page, search stops there — a single request — without firing the concurrent
 // follow-on batch. This keeps the common case fast.