feat(hack): rewrite check-readiness as a Go command with test suite - #2755

	cfg.setColors()

	if _, err := exec.LookPath(cfg.kubectl[0]); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s not found in PATH\n", cfg.kubectl[0])
		return 2
	}

// fetchRows runs kubectl get and returns raw jsonpath output.
func (cfg *config) fetchRows(e entry) (string, error) {
	scopeArgs := cfg.buildScopeArgs(e.scope)

	var jsonpath string
	if e.condType == "_phase" {
		jsonpath = `{range .items[*]}{.metadata.namespace}{"\x1f"}{.metadata.name}{"\x1f"}{.status.phase}{"\x1f"}{""}{"\x1f"}{""}{"\x1f"}{"false"}{"\n"}{end}`
	} else {
		suspendField := `{"false"}`
		if e.supportsSuspend {
			suspendField = `{.spec.suspend}`
		}
		var b strings.Builder
		b.WriteString(`{range .items[*]}`)
		b.WriteString(`{.metadata.namespace}{"\x1f"}`)
		b.WriteString(`{.metadata.name}{"\x1f"}`)
		b.WriteString(`{.status.conditions[?(@.type=="` + e.condType + `")].status}{"\x1f"}`)
		b.WriteString(`{.status.conditions[?(@.type=="` + e.condType + `")].reason}{"\x1f"}`)
		b.WriteString(`{.status.conditions[?(@.type=="` + e.condType + `")].message}{"\x1f"}`)
		b.WriteString(suspendField + `{"\n"}`)
		b.WriteString(`{end}`)
		jsonpath = b.String()
	}

	args := append([]string{}, cfg.kubectl[1:]...)
	args = append(args, "get", e.kind)
	args = append(args, scopeArgs...)
	args = append(args, "-o", "jsonpath="+jsonpath)

	cmd := exec.Command(cfg.kubectl[0], args...)
	var stderr strings.Builder
	cmd.Stderr = &stderr
	out, err := cmd.Output()
	if err != nil {
		if stderr.Len() > 0 {
			return "", fmt.Errorf("%s", strings.TrimSpace(stderr.String()))
		}
		return "", err
	}
	return string(out), nil
}

func (cfg *config) runOnce() string {
	cfg.foundIssues = false
	cfg.ensureAPIResources()

	entries := append([]entry{}, coreKinds...)
	if !cfg.coreOnly {
		entries = append(entries, fluxExtraKinds...)
		entries = append(entries, clusterKinds...)
		entries = append(entries, pvcKind)
	}

	rowsByIdx := make([]string, len(entries))
	errsByIdx := make([]error, len(entries))

	// Phase 1: fetch.
	if cfg.parallel {
		var wg sync.WaitGroup
		for idx := range entries {
			e := entries[idx]
			if !cfg.kindExists(e.kind) {
				continue
			}
			wg.Add(1)
			go func(idx int, e entry) {
				defer wg.Done()
				rowsByIdx[idx], errsByIdx[idx] = cfg.fetchRows(e)
			}(idx, e)
		}
		wg.Wait()
	} else {
		for idx := range entries {
			e := entries[idx]
			if !cfg.kindExists(e.kind) {
				continue
			}
			rowsByIdx[idx], errsByIdx[idx] = cfg.fetchRows(e)
		}
	}

	var b strings.Builder

	// Phase 2: process in catalog order.
	for idx := range entries {
		e := entries[idx]
		if !cfg.kindExists(e.kind) {
			fmt.Fprintf(&b, "%s--- %s: CRD not installed, skipping%s\n", cfg.dim, e.kind, cfg.reset)
			continue
		}
		if errsByIdx[idx] != nil {
			fmt.Fprintf(&b, "%sError fetching %s: %v%s\n", cfg.red, e.kind, errsByIdx[idx], cfg.reset)
			cfg.foundIssues = true
			continue
		}
		cfg.processRows(e, rowsByIdx[idx], &b)
	}

	if !cfg.foundIssues {
		fmt.Fprintf(&b, "%s%sAll resources are ready.%s\n", cfg.green, cfg.bold, cfg.reset)
	}

	return b.String()
}